package algorithms

import (
	"encoding/json"
	"fmt"
	"strings"

	"navigation-service/internal/models"
)

// PromptEngineer AI提示词工程师
type PromptEngineer struct {
	templates map[string]string
}

// NewPromptEngineer 创建提示词工程师
func NewPromptEngineer() *PromptEngineer {
	pe := &PromptEngineer{
		templates: make(map[string]string),
	}

	// 初始化提示词模板
	pe.initializeTemplates()

	return pe
}

// initializeTemplates 初始化提示词模板
func (pe *PromptEngineer) initializeTemplates() {
	pe.templates["grouping"] = `你是一个专业的网站分类专家。请根据以下网站信息，将它们按照主题和用途进行智能分组。

网站信息：
{{.URLs}}

请按照以下要求进行分组：
1. 每组包含3-20个相关网站
2. 为每组起一个简洁明了的名称（2-6个字符）
3. 为每组写一个简短的描述（10-30个字符）
4. 选择适合的图标（emoji）
5. 为每组选择一种颜色（十六进制颜色代码）

请以JSON格式返回结果：
{
  "groups": [
    {
      "name": "分组名称",
      "description": "分组描述",
      "icon": "🎯",
      "color": "#ff6b6b",
      "urls": ["url1", "url2", ...],
      "confidence": 0.85
    }
  ]
}`

	pe.templates["optimize_group"] = `你是一个网站分组优化专家。请优化以下分组结果，使其更加合理和有用。

原始分组：
{{.Groups}}

用户偏好：
{{.UserPrompt}}

请优化分组，考虑以下因素：
1. 用户的具体需求和偏好
2. 网站的实际用途和相关性
3. 分组的实用性和可操作性
4. 避免过度细分或过度合并

请以JSON格式返回优化后的结果：
{
  "groups": [
    {
      "name": "优化后的分组名称",
      "description": "优化后的分组描述",
      "icon": "🎯",
      "color": "#ff6b6b",
      "urls": ["url1", "url2", ...],
      "confidence": 0.9,
      "reason": "分组原因说明"
    }
  ],
  "changes": [
    {
      "type": "merge|split|rename|move",
      "description": "变更说明"
    }
  ]
}`

	pe.templates["analyze_patterns"] = `你是一个用户行为分析专家。请分析以下网站访问模式，识别用户的兴趣和习惯。

访问数据：
{{.VisitData}}

时间模式：
{{.TimePatterns}}

请分析并返回：
1. 用户的主要兴趣领域
2. 访问时间偏好
3. 网站使用习惯
4. 建议的分组策略

请以JSON格式返回分析结果：
{
  "interests": ["兴趣1", "兴趣2", ...],
  "timePreferences": {
    "peakHours": [9, 14, 20],
    "weekdayPattern": "工作日主要访问工作相关网站",
    "weekendPattern": "周末主要访问娱乐相关网站"
  },
  "usageHabits": {
    "frequentDomains": ["domain1", "domain2", ...],
    "browsingStyle": "深度浏览|快速浏览|混合模式"
  },
  "groupingSuggestions": [
    {
      "strategy": "按兴趣领域分组",
      "reason": "用户有明显的兴趣偏好"
    }
  ]
}`

	pe.templates["generate_description"] = `你是一个网站描述生成专家。请为以下网站分组生成简洁而准确的描述。

分组信息：
- 名称：{{.GroupName}}
- 网站列表：{{.URLs}}
- 关键词：{{.Keywords}}

请生成：
1. 一个简洁的分组描述（10-30个字符）
2. 一个详细的分组说明（50-100个字符）
3. 3-5个相关标签

请以JSON格式返回：
{
  "shortDescription": "简洁描述",
  "detailedDescription": "详细说明",
  "tags": ["标签1", "标签2", "标签3"]
}`

	pe.templates["suggest_improvements"] = `你是一个用户体验优化专家。请分析以下分组结果，提出改进建议。

当前分组：
{{.CurrentGroups}}

用户反馈：
{{.UserFeedback}}

统计数据：
{{.Statistics}}

请分析并返回：
1. 当前分组的问题
2. 改进建议
3. 优化方案
4. 预期效果

请以JSON格式返回：
{
  "issues": [
    {
      "type": "问题类型",
      "description": "问题描述",
      "severity": "high|medium|low"
    }
  ],
  "suggestions": [
    {
      "action": "建议行动",
      "description": "详细说明",
      "priority": "high|medium|low"
    }
  ],
  "optimizationPlan": {
    "steps": ["步骤1", "步骤2", ...],
    "expectedImprovement": "预期改进效果"
  }
}`
}

// GenerateGroupingPrompt 生成分组提示词
func (pe *PromptEngineer) GenerateGroupingPrompt(features []models.URLFeature, config models.AIGroupingConfig) (string, error) {
	// 准备URL信息
	var urlInfos []string
	for _, feature := range features {
		urlInfo := fmt.Sprintf("- %s (%s) - %s", feature.URL, feature.Title, feature.Category)
		urlInfos = append(urlInfos, urlInfo)
	}

	// 替换模板变量
	prompt := pe.templates["grouping"]
	prompt = strings.ReplaceAll(prompt, "{{.URLs}}", strings.Join(urlInfos, "\n"))

	// 添加用户提示
	if config.UserPrompt != "" {
		prompt += "\n\n用户特殊要求：\n" + config.UserPrompt
	}

	return prompt, nil
}

// GenerateOptimizationPrompt 生成优化提示词
func (pe *PromptEngineer) GenerateOptimizationPrompt(groups []models.AIGroup, userPrompt string) (string, error) {
	// 准备分组信息
	var groupInfos []string
	for i, group := range groups {
		groupInfo := fmt.Sprintf("分组 %d: %s (%s) - %d个网站", i+1, group.Name, group.Description, group.URLCount)
		groupInfos = append(groupInfos, groupInfo)
	}

	// 替换模板变量
	prompt := pe.templates["optimize_group"]
	prompt = strings.ReplaceAll(prompt, "{{.Groups}}", strings.Join(groupInfos, "\n"))
	prompt = strings.ReplaceAll(prompt, "{{.UserPrompt}}", userPrompt)

	return prompt, nil
}

// GenerateAnalysisPrompt 生成分析提示词
func (pe *PromptEngineer) GenerateAnalysisPrompt(features []models.URLFeature) (string, error) {
	// 准备访问数据
	var visitData []string
	for _, feature := range features {
		visitInfo := fmt.Sprintf("- %s: 访问%d次, 类别:%s, 关键词:%s",
			feature.Title, feature.VisitCount, feature.Category,
			strings.Join(feature.Keywords, ","))
		visitData = append(visitData, visitInfo)
	}

	// 分析时间模式
	timePatterns := pe.analyzeTimePatterns(features)

	// 替换模板变量
	prompt := pe.templates["analyze_patterns"]
	prompt = strings.ReplaceAll(prompt, "{{.VisitData}}", strings.Join(visitData, "\n"))
	prompt = strings.ReplaceAll(prompt, "{{.TimePatterns}}", timePatterns)

	return prompt, nil
}

// GenerateDescriptionPrompt 生成描述提示词
func (pe *PromptEngineer) GenerateDescriptionPrompt(group models.AIGroup) (string, error) {
	// 提取关键词
	var keywords []string
	for _, url := range group.URLs {
		// 这里可以从URL中提取关键词，简化处理
		parts := strings.Split(url, "/")
		if len(parts) > 2 {
			keywords = append(keywords, parts[len(parts)-1])
		}
	}

	// 替换模板变量
	prompt := pe.templates["generate_description"]
	prompt = strings.ReplaceAll(prompt, "{{.GroupName}}", group.Name)
	prompt = strings.ReplaceAll(prompt, "{{.URLs}}", strings.Join(group.URLs, ", "))
	prompt = strings.ReplaceAll(prompt, "{{.Keywords}}", strings.Join(keywords, ", "))

	return prompt, nil
}

// GenerateImprovementPrompt 生成改进建议提示词
func (pe *PromptEngineer) GenerateImprovementPrompt(groups []models.AIGroup, userFeedback string, stats models.GroupingStatistics) (string, error) {
	// 准备当前分组信息
	var groupInfos []string
	for i, group := range groups {
		groupInfo := fmt.Sprintf("分组 %d: %s - %d个网站, 置信度:%.2f",
			i+1, group.Name, group.URLCount, group.Confidence)
		groupInfos = append(groupInfos, groupInfo)
	}

	// 准备统计信息
	statsInfo := fmt.Sprintf("总URL数: %d, 已分组: %d, 未分组: %d, 平均置信度: %.2f",
		stats.TotalURLs, stats.GroupedURLs, stats.UnassignedURLs, stats.AvgConfidence)

	// 替换模板变量
	prompt := pe.templates["suggest_improvements"]
	prompt = strings.ReplaceAll(prompt, "{{.CurrentGroups}}", strings.Join(groupInfos, "\n"))
	prompt = strings.ReplaceAll(prompt, "{{.UserFeedback}}", userFeedback)
	prompt = strings.ReplaceAll(prompt, "{{.Statistics}}", statsInfo)

	return prompt, nil
}

// analyzeTimePatterns 分析时间模式
func (pe *PromptEngineer) analyzeTimePatterns(features []models.URLFeature) string {
	// 统计总体访问模式
	totalPattern := make([]int, 24)
	workdayCount := 0
	weekendCount := 0

	for _, feature := range features {
		for hour, count := range feature.VisitPattern {
			totalPattern[hour] += count
		}

		// 简化的工作日/周末判断
		if feature.VisitCount > 0 {
			workdayCount += feature.VisitCount / 2
			weekendCount += feature.VisitCount / 2
		}
	}

	// 找到访问高峰时段
	var peakHours []int
	maxVisits := 0
	for hour, count := range totalPattern {
		if count > maxVisits {
			maxVisits = count
			peakHours = []int{hour}
		} else if count == maxVisits && count > 0 {
			peakHours = append(peakHours, hour)
		}
	}

	// 生成时间模式描述
	patternDesc := fmt.Sprintf("访问高峰时段: %v, 工作日访问: %d次, 周末访问: %d次",
		peakHours, workdayCount, weekendCount)

	return patternDesc
}

// ParseAIResponse 解析AI响应
func (pe *PromptEngineer) ParseAIResponse(response string, responseType string) (interface{}, error) {
	switch responseType {
	case "grouping":
		var result struct {
			Groups []models.AIGroup `json:"groups"`
		}
		err := json.Unmarshal([]byte(response), &result)
		return result, err

	case "optimize_group":
		var result struct {
			Groups  []models.AIGroup `json:"groups"`
			Changes []struct {
				Type        string `json:"type"`
				Description string `json:"description"`
			} `json:"changes"`
		}
		err := json.Unmarshal([]byte(response), &result)
		return result, err

	case "analyze_patterns":
		var result struct {
			Interests           []string               `json:"interests"`
			TimePreferences     map[string]interface{} `json:"timePreferences"`
			UsageHabits         map[string]interface{} `json:"usageHabits"`
			GroupingSuggestions []struct {
				Strategy string `json:"strategy"`
				Reason   string `json:"reason"`
			} `json:"groupingSuggestions"`
		}
		err := json.Unmarshal([]byte(response), &result)
		return result, err

	case "generate_description":
		var result struct {
			ShortDescription    string   `json:"shortDescription"`
			DetailedDescription string   `json:"detailedDescription"`
			Tags                []string `json:"tags"`
		}
		err := json.Unmarshal([]byte(response), &result)
		return result, err

	case "suggest_improvements":
		var result struct {
			Issues []struct {
				Type        string `json:"type"`
				Description string `json:"description"`
				Severity    string `json:"severity"`
			} `json:"issues"`
			Suggestions []struct {
				Action      string `json:"action"`
				Description string `json:"description"`
				Priority    string `json:"priority"`
			} `json:"suggestions"`
			OptimizationPlan struct {
				Steps               []string `json:"steps"`
				ExpectedImprovement string   `json:"expectedImprovement"`
			} `json:"optimizationPlan"`
		}
		err := json.Unmarshal([]byte(response), &result)
		return result, err

	default:
		return nil, fmt.Errorf("未知的响应类型: %s", responseType)
	}
}

// ValidatePrompt 验证提示词
func (pe *PromptEngineer) ValidatePrompt(prompt string) error {
	if strings.TrimSpace(prompt) == "" {
		return fmt.Errorf("提示词不能为空")
	}

	if len(prompt) < 10 {
		return fmt.Errorf("提示词太短，至少需要10个字符")
	}

	if len(prompt) > 10000 {
		return fmt.Errorf("提示词太长，最多10000个字符")
	}

	return nil
}

// OptimizePrompt 优化提示词
func (pe *PromptEngineer) OptimizePrompt(prompt string) string {
	// 移除多余的空格和换行
	prompt = strings.TrimSpace(prompt)

	// 替换多个连续空格为单个空格
	prompt = strings.ReplaceAll(prompt, "  ", " ")

	// 确保句子以句号结尾
	if !strings.HasSuffix(prompt, ".") && !strings.HasSuffix(prompt, "!") && !strings.HasSuffix(prompt, "?") {
		prompt += "."
	}

	return prompt
}

// GetTemplate 获取模板
func (pe *PromptEngineer) GetTemplate(templateName string) (string, error) {
	template, exists := pe.templates[templateName]
	if !exists {
		return "", fmt.Errorf("模板 %s 不存在", templateName)
	}
	return template, nil
}

// ListTemplates 列出所有模板
func (pe *PromptEngineer) ListTemplates() []string {
	var templates []string
	for name := range pe.templates {
		templates = append(templates, name)
	}
	return templates
}

// AddTemplate 添加自定义模板
func (pe *PromptEngineer) AddTemplate(name, template string) error {
	if name == "" {
		return fmt.Errorf("模板名称不能为空")
	}

	if template == "" {
		return fmt.Errorf("模板内容不能为空")
	}

	pe.templates[name] = template
	return nil
}

// UpdateTemplate 更新模板
func (pe *PromptEngineer) UpdateTemplate(name, template string) error {
	if _, exists := pe.templates[name]; !exists {
		return fmt.Errorf("模板 %s 不存在", name)
	}

	return pe.AddTemplate(name, template)
}

// DeleteTemplate 删除模板
func (pe *PromptEngineer) DeleteTemplate(name string) error {
	if _, exists := pe.templates[name]; !exists {
		return fmt.Errorf("模板 %s 不存在", name)
	}

	delete(pe.templates, name)
	return nil
}
